Jassif Team Institution

const fs = require('fs');
const path = require('path');

// எடுத்துக்காட்டுக்கு ஒரு மாதிரி கோப்பை உருவாக்கு
const sampleFile = path.join(__dirname, 'readstream-example.txt');
fs.writeFileSync(sampleFile, 'This is a test file.\nIt has multiple lines.\nEach line has its own content.\nStreaming makes file reading efficient.');

// கோப்பிலிருந்து வாசிக்க ஒரு ReadStream உருவாக்க
const readStream = fs.createReadStream(sampleFile, {
  // விருப்பங்கள்
  encoding: 'utf8',  // encoding ஐ அமை (utf8, ascii, binary, முதலியன)
  highWaterMark: 64, // பைட்டுகளில் Buffer அளவு
  autoClose: true    // ஸ்ட்ரீம் முடிவடையும் போது தானாகவே கோப்பு descriptor ஐ மூடு
});

console.log('File ReadStream properties:');
console.log(`- Path: ${readStream.path}`);
console.log(`- Pending: ${readStream.pending}`);
console.log(`- High Water Mark: ${readStream.readableHighWaterMark} bytes`);

// ஸ்ட்ரீம் நிகழ்வுகளைக் கையாள
readStream.on('open', (fd) => {
  console.log(`File opened with descriptor: ${fd}`);
});

readStream.on('ready', () => {
  console.log('ReadStream is ready');
});

// தரவு நிகழ்வுகளைக் கையாள
readStream.on('data', (chunk) => {
  console.log('\nReceived chunk:');
  console.log('-'.repeat(20));
  console.log(chunk);
  console.log('-'.repeat(20));
  console.log(`Bytes read so far: ${readStream.bytesRead}`);
});

readStream.on('end', () => {
  console.log('\nReached end of file');
  console.log(`Total bytes read: ${readStream.bytesRead}`);
  
  // மாதிரி கோப்பை சுத்தம் செய்
  fs.unlinkSync(sampleFile);
  console.log('Sample file removed');
});

readStream.on('close', () => {
  console.log('Stream closed');
});

readStream.on('error', (err) => {
  console.error(`Error: ${err.message}`);
});

const fs = require('fs');
const path = require('path');

// ஓட்டக் கட்டுப்பாட்டு எடுத்துக்காட்டுக்கு ஒரு பெரிய மாதிரி கோப்பை உருவாக்கு
const flowFile = path.join(__dirname, 'flow-control-example.txt');
let sampleContent = '';
for (let i = 1; i <= 1000; i++) {
  sampleContent += `This is line ${i} of the test file.\n`;
}
fs.writeFileSync(flowFile, sampleContent);

// ஒரு ReadStream உருவாக்க
const readStream = fs.createReadStream(flowFile, {
  encoding: 'utf8',
  highWaterMark: 1024 // 1KB buffer
});

let chunkCount = 0;
let totalBytes = 0;
let isPaused = false;

// ஓட்டக் கட்டுப்பாட்டுடன் தரவு chunks களைக் கையாள
readStream.on('data', (chunk) => {
  chunkCount++;
  totalBytes += chunk.length;
  
  console.log(`Chunk #${chunkCount} received, size: ${chunk.length} bytes`);
  
  // ஓட்டக் கட்டுப்பாட்டை நிரூபிக்க ஒவ்வொரு 5 chunks க்கும் ஸ்ட்ரீமை இடைநிறுத்து
  if (chunkCount % 5 === 0 && !isPaused) {
    console.log('\nPausing the stream for 1 second...');
    isPaused = true;
    
    // ஸ்ட்ரீமை இடைநிறுத்து
    readStream.pause();
    
    // 1 விநாடிக்குப் பிறகு மீண்டும் தொடங்கு
    setTimeout(() => {
      console.log('Resuming the stream...\n');
      isPaused = false;
      readStream.resume();
    }, 1000);
  }
});

readStream.on('end', () => {
  console.log(`\nFinished reading file. Received ${chunkCount} chunks, ${totalBytes} bytes total.`);
  
  // மாதிரி கோப்பை சுத்தம் செய்
  fs.unlinkSync(flowFile);
  console.log('Sample file removed');
});

readStream.on('error', (err) => {
  console.error(`Error: ${err.message}`);
});

const fs = require('fs');
const path = require('path');

// ஒரு மாதிரி கோப்பை உருவாக்கு
const readableFile = path.join(__dirname, 'readable-example.txt');
fs.writeFileSync(readableFile, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.repeat(100));

// auto-flowing இல்லாமல் ஒரு ReadStream உருவாக்கு
const readStream = fs.createReadStream(readableFile, {
  highWaterMark: 32 // பல வாசிப்புகளை நிரூபிக்க சிறிய buffer
});

console.log('Using the readable event and read() method:');

// கைமுறை வாசிப்புக்கு 'readable' நிகழ்வைப் பயன்படுத்துதல்
readStream.on('readable', () => {
  let chunk;
  // வாசிக்க இன்னும் தரவு இல்லாதபோது read() null திரும்பும்
  while (null !== (chunk = readStream.read(16))) {
    console.log(`Read ${chunk.length} bytes: ${chunk.toString('utf8').substring(0, 10)}...`);
  }
});

readStream.on('end', () => {
  console.log('End of stream reached');
  
  // மாதிரி கோப்பை சுத்தம் செய்
  fs.unlinkSync(readableFile);
  console.log('Sample file removed');
});

readStream.on('error', (err) => {
  console.error(`Error: ${err.message}`);
});

const fs = require('fs');
const path = require('path');
const zlib = require('zlib');

// மூல மற்றும் இலக்கு கோப்பு பாதைகள்
const sourceFile = path.join(__dirname, 'pipe-source-example.txt');
const destFile = path.join(__dirname, 'pipe-destination.txt');
const compressedFile = path.join(__dirname, 'pipe-compressed.gz');

// மாதிரி உள்ளடக்கத்தை உருவாக்கு
fs.writeFileSync(sourceFile, 'This is the source content for the pipe example.\n'.repeat(100));

// ReadStream மற்றும் பல்வேறு WriteStreams உருவாக்கு
const readStream = fs.createReadStream(sourceFile);
const writeStream = fs.createWriteStream(destFile);
const compressStream = zlib.createGzip(); // சுருக்கம் transform ஸ்ட்ரீம்
const compressedWriteStream = fs.createWriteStream(compressedFile);

// ReadStream ஐ நேரடியாக WriteStream க்கு pipe செய்
readStream.pipe(writeStream);

// நிறைவு நிகழ்வுகளைக் கேள்
writeStream.on('finish', () => {
  console.log(`File copied from ${sourceFile} to ${destFile}`);
  
  // தொடர்ச்சியான pipes ஐ நிரூபிக்க ஒரு புதிய ReadStream உருவாக்கு
  const readStream2 = fs.createReadStream(sourceFile);
  
  // பல pipes ஐ தொடர்ச்சியாக இணை: read -> compress -> write
  readStream2.pipe(compressStream).pipe(compressedWriteStream);
  
  compressedWriteStream.on('finish', () => {
    console.log(`File compressed from ${sourceFile} to ${compressedFile}`);
    
    // கோப்பு அளவுகளை ஒப்பிடு
    const originalSize = fs.statSync(sourceFile).size;
    const compressedSize = fs.statSync(compressedFile).size;
    console.log(`Original size: ${originalSize} bytes`);
    console.log(`Compressed size: ${compressedSize} bytes`);
    console.log(`Compression ratio: ${(compressedSize / originalSize * 100).toFixed(2)}%`);
    
    // நிரூபணத்திற்குப் பிறகு கோப்புகளை சுத்தம் செய்
    [sourceFile, destFile, compressedFile].forEach(file => {
      fs.unlinkSync(file);
    });
    console.log('All sample files removed');
  });
});

// பிழைகளைக் கையாள
readStream.on('error', (err) => console.error(`Read error: ${err.message}`));
writeStream.on('error', (err) => console.error(`Write error: ${err.message}`));
compressStream.on('error', (err) => console.error(`Compression error: ${err.message}`));
compressedWriteStream.on('error', (err) => console.error(`Compressed write error: ${err.message}`));

// process.stdin ஒரு ReadStream ஆகும்

console.log('Enter some text (press Ctrl+D or Ctrl+C to end input):');

// Buffer பொருள்களுக்குப் பதிலாக சரங்களைப் பெற utf8 க்கு encoding ஐ அமை
process.stdin.setEncoding('utf8');

let inputData = '';

// stdin இலிருந்து தரவைக் கையாள
process.stdin.on('data', (chunk) => {
  console.log(`Received chunk: "${chunk.trim()}"`);
  inputData += chunk;
});

// உள்ளீட்டின் முடிவைக் கையாள
process.stdin.on('end', () => {
  console.log('\nEnd of input.');
  console.log(`Total input received: ${inputData.length} characters`);
  console.log('You entered:');
  console.log('-'.repeat(20));
  console.log(inputData);
  console.log('-'.repeat(20));
});

// Ctrl+C (SIGINT) ஐக் கையாள
process.on('SIGINT', () => {
  console.log('\nInput interrupted with Ctrl+C');
  process.exit();
});

// குறிப்பு: இந்த எடுத்துக்காட்டுக்கு ஒரு முனையத்தில் பயனர் உள்ளீடு தேவை
// W3Schools TryIt எடிட்டரில் திறம்பட நிரூபிக்க முடியாது

const http = require('http');

// ஒரு HTTP சேவையகத்தை உருவாக்கு
const server = http.createServer((req, res) => {
  // req ஒரு http.IncomingMessage, இது ஒரு ReadStream ஆகும்
  console.log(`Received ${req.method} request to ${req.url}`);
  
  // பதில் தலைப்புகளை அமை
  res.setHeader('Content-Type', 'text/plain');
  
  // வெவ்வேறு வகையான கோரிக்கைகளைக் கையாள
  if (req.method === 'GET') {
    res.end('Send a POST request with a body to see the ReadStream in action');
  }
  else if (req.method === 'POST') {
    // கோரிக்கை ஸ்ட்ரீமுக்கான encoding ஐ அமை
    req.setEncoding('utf8');
    
    let body = '';
    
    // கோரிக்கை ஸ்ட்ரீமிலிருந்து தரவு நிகழ்வுகளைக் கையாள
    req.on('data', (chunk) => {
      console.log(`Received chunk of ${chunk.length} bytes`);
      body += chunk;
      
      // ஒரு எளிய flood பாதுகாப்பை செயல்படுத்து
      if (body.length > 1e6) {
        // உடல் மிகப் பெரியதாக இருந்தால், ஸ்ட்ரீமை அழி
        body = '';
        res.writeHead(413, {'Content-Type': 'text/plain'});
        res.end('Request entity too large');
        req.destroy();
      }
    });
    
    // கோரிக்கை ஸ்ட்ரீமின் முடிவைக் கையாள
    req.on('end', () => {
      console.log('End of request data');
      
      try {
        // JSON ஆக parse செய்ய முயற்சி
        const data = JSON.parse(body);
        console.log('Parsed JSON data:', data);
        
        // ஒரு பதிலை அனுப்பு
        res.writeHead(200, {'Content-Type': 'application/json'});
        res.end(JSON.stringify({
          message: 'Data received',
          size: body.length,
          data: data
        }));
      } catch (e) {
        // செல்லுபடியாகும் JSON இல்லையென்றால், raw தரவை echo back செய்
        console.log('Could not parse as JSON, treating as plain text');
        
        res.writeHead(200, {'Content-Type': 'text/plain'});
        res.end(`Received ${body.length} bytes of data:\n${body}`);
      }
    });
  }
  else {
    // மற்ற HTTP முறைகளுக்கு
    res.writeHead(405, {'Content-Type': 'text/plain'});
    res.end('Method not allowed');
  }
});

// சேவையகத்தைத் தொடங்கு
const PORT = 8080;
server.listen(PORT, () => {
  console.log(`HTTP ReadStream example server running at http://localhost:${PORT}`);
  console.log('To test:');
  console.log(`1. Open http://localhost:${PORT} in a browser for GET request`);
  console.log(`2. Use curl or Postman to send POST requests with a body to http://localhost:${PORT}`);
});

// குறிப்பு: curl உடன் சோதிக்க:
// curl -X POST -H "Content-Type: application/json" -d '{"name":"John","age":30}' http://localhost:8080

const fs = require('fs');
const path = require('path');

// சரியான பிழை கையாளுதலுடன் ஒரு ReadStream உருவாக்கி கையாளும் செயல்பாடு
function readWithErrorHandling(filePath) {
  console.log(`Attempting to read: ${filePath}`);
  
  // ReadStream ஐ உருவாக்கு
  const readStream = fs.createReadStream(filePath);
  
  // முடிவு அல்லது பிழையைப் பிடிக்க promise ஐ அமை
  return new Promise((resolve, reject) => {
    let data = '';
    
    // தரவு நிகழ்வுகளைக் கையாள
    readStream.on('data', (chunk) => {
      data += chunk;
    });
    
    // வெற்றிகரமான நிறைவைக் கையாள
    readStream.on('end', () => {
      console.log(`Successfully read ${readStream.bytesRead} bytes from ${filePath}`);
      resolve(data);
    });
    
    // பிழைகளைக் கையாள
    readStream.on('error', (err) => {
      console.error(`Error reading ${filePath}: ${err.message}`);
      reject(err);
    });
    
    // ஸ்ட்ரீம் மூடல் (பிழை இருந்தாலும் எப்போதும் நடக்கும்)
    readStream.on('close', () => {
      console.log(`Stream for ${filePath} closed`);
    });
  });
}

// இரண்டும் இருக்கும் மற்றும் இல்லாத கோப்புகளுடன் சோதிக்க
const existingFile = path.join(__dirname, 'test-existing.txt');
const nonExistingFile = path.join(__dirname, 'non-existing-file.txt');

// சோதனை கோப்பை உருவாக்கு
fs.writeFileSync(existingFile, 'This is test content for error handling example');

// எடுத்துக்காட்டு 1: இருக்கும் கோப்பை வாசித்தல்
console.log('Example 1: Reading an existing file');
readWithErrorHandling(existingFile)
  .then(data => {
    console.log('File content:', data);
    
    // எடுத்துக்காட்டு 2: இல்லாத கோப்பை வாசித்தல்
    console.log('\nExample 2: Reading a non-existing file');
    return readWithErrorHandling(nonExistingFile);
  })
  .catch(err => {
    console.log('Error caught in Promise catch:', err.message);
  })
  .finally(() => {
    // சோதனை கோப்பை சுத்தம் செய்
    if (fs.existsSync(existingFile)) {
      fs.unlinkSync(existingFile);
      console.log('Test file removed');
    }
  });

// எடுத்துக்காட்டு 3: அழிக்கப்பட்ட ஸ்ட்ரீம்களை நிரூபித்தல்
console.log('\nExample 3: Demonstrating destroyed streams');
const destroyTestFile = path.join(__dirname, 'destroy-test.txt');
fs.writeFileSync(destroyTestFile, 'A'.repeat(10000));

const destroyStream = fs.createReadStream(destroyTestFile);

destroyStream.on('data', (chunk) => {
  console.log(`Received ${chunk.length} bytes before destroying the stream`);
  
  // முதல் chunk பெற்ற பிறகு ஸ்ட்ரீமை அழி
  console.log('Deliberately destroying the stream');
  destroyStream.destroy(new Error('Stream manually destroyed'));
});

destroyStream.on('error', (err) => {
  console.error(`Destruction error: ${err.message}`);
});

destroyStream.on('close', () => {
  console.log('Destroyed stream closed');
  
  // சுத்தம் செய்
  fs.unlinkSync(destroyTestFile);
  console.log('Destroy test file removed');
});